// #include<iostream>
// #include<unistd.h>
// #include<thread>

// using namespace std;

// void thread_tun()
// {
//     while(true)
//     {
//         cout<<"我是新线程"<<endl;
//         sleep(1);
//     }
// }

// int main()
// {
//     thread t1(thread_tun);
//     while(true)
//     {
//         cout<<"我是主线程"<<endl;
//         sleep(1);
//     }
//     t1.join();
//     return 0;
// }




#include<iostream>
#include<string.h>
#include<pthread.h>
#include<stdio.h>
#include<vector>
#include<assert.h>
#include<unistd.h>
#include<memory>
#include"mythread.hpp"
using namespace std;

void* getticket(void*args)
{
    string username=static_cast<const char*> (args);
   int cnt=3;
   while(cnt--)
    {
        cout<<"User name:"<<username<<"get tickets ing..."<<endl;
        sleep(1);
    }
}

int main()
{
unique_ptr<thread> thread1(new thread(getticket,(void*)"user1",1));
unique_ptr<thread> thread2(new thread(getticket,(void*)"user2",2));
unique_ptr<thread> thread3(new thread(getticket,(void*)"user3",3));
thread1->join();
thread2->join();
thread3->join();
    return 0;
}


// string changeID(const pthread_t&thread_id)
// {
//     char id[128];
//     snprintf(id,sizeof id,"0x%x",thread_id);//以十六进制的方式将参数打印进id缓冲区并返回
//     return id;
// }

// void* start_rontine(void* arg)
// {
//     string threadname=static_cast<const char*> (arg);
    
//     int cnt=3;
//     while(cnt--)
//     {
// cout<<"pthread_self get newthreadid: "<<threadname<<changeID(pthread_self())<<endl;//pthread_self获取的线程id
// sleep(1);
//     }
    
//     return nullptr;
// }
// int main()
// {
// pthread_t id;
// int n=pthread_create(&id,nullptr,start_rontine,(void*)"thread1");//创建新线程
// assert(n==0);
// char newthreadid[128];
// snprintf(newthreadid,sizeof newthreadid,"0x%x",id);
// cout<<"new threadid: "<<newthreadid<<endl;//pthread_create获取的线程id
//  pthread_detach(id);//线程分离

// int m=pthread_join(id,nullptr);//阻塞等待回收线程

// cout<<"new thread ret:"<<m<<":"<<strerror(m)<<endl;//若新线程分离成功则主线程回收新线程失败
// while(true)
// {
//     cout<<"main thread"<<endl;
//     sleep(1);
// }
//     return 0;
// }

//int g_val=0;

// string fun()
// {
//     return "我是一个fun函数";
// }
// class threadData//建立结构体
// {
//     public:
// pthread_t _pid;//线程id
// int _num;
// char _buffer[64];
// };

// void* start_rontine(void* args)
// {
//    // string str=static_cast<const char*>(args);
//    threadData* td=static_cast<threadData*>(args);
//    int cnt=3;//在线程内定义一个局部变量--存储在线程的独立栈-具有独立性
//     while(cnt--)
//     {
//        // cout<<"我是一个新线程，我的参数是："<<str<<" g_val:"<<g_val<<" "<<fun()<<endl;
//        cout<<"我是一个新线程，"<<td->_buffer<<"线程内自增变量cnt: "<<cnt<<"&cnt:"<<&cnt<<endl;
//     //    int* ptr=NULL;
//     //    *ptr=0;
//     //delete td;//释放指向的结构体资源
//         sleep(1);
//        //  pthread_exit(nullptr);
//     }
//    return (void*)520;

// }
// #define NUM 3
// int main()
// {
//     vector<threadData*> threads;
//     for(int i=0;i<NUM;i++)
// {
//  pthread_t id;//创建一个新的线程id
//     threadData* ta=new threadData();
//     ta->_num=i;
//     snprintf(ta->_buffer,sizeof ta->_buffer,"%s:%d","newthread",ta->_num);
//     threads.push_back(ta);
//     int n=pthread_create(&ta->_pid,nullptr,start_rontine,(void*)ta);
//     assert(n==0);
// } 

// sleep(2);
// for(const auto& it:threads)
// {
//     int n=pthread_cancel(it->_pid);
//     assert(n==0);
//     cout<<"new thread "<<it->_num<<"cancel success"<<endl;
// }
//    // int n=pthread_create(&id,nullptr,start_rontine,(void*)"new_pthread");
//    void* ret;//初始化
// for(const auto &it:threads)
// {
   
//    int n= pthread_join(it->_pid,&ret);//等待回收线程
//      assert(n==0);
//      cout<<"newpthread "<<it->_num<<" join success"<<"return val:"<<(long long)ret<<endl;//Linux下void*大小为8个字节，所以强转为整形要用到long long
//      delete it;
// }
// while(true)
// {
//   //  cout<<"我是主线程"<<" g_val:"<<g_val++<<" "<<fun()<<endl;
//    cout<<"我是主线程，"<<endl;
//     sleep(1);
// }
//     return 0;
// }




//pthread_mutex_t mutex=PTHREAD_MUTEX_ININIALIZER//定义了全局锁
// int ticket=1000;
// pthread_mutex_t mutex;
// void* getticket(void* args)
// {
//     string username=static_cast<const char*>(args);
    
//     while(ticket)
//     {pthread_mutex_lock(&mutex);//加锁
//         if(ticket>0)
//         {
//        usleep(1234);//1-1000-1000000
//     cout<<username<<"正在抢票中。。。抢前票数还有:"<<ticket<<endl;
//     ticket--;
//  pthread_mutex_unlock(&mutex);
//         }else
//         { pthread_mutex_unlock(&mutex);
//             break;
//         }
        
//     }
    
// }

// int main()
// {
// unique_ptr<thread> thread1(new thread(getticket,(void*)"user1",1));
// unique_ptr<thread> thread2(new thread(getticket,(void*)"user2",2));
// unique_ptr<thread> thread3(new thread(getticket,(void*)"user3",3));

// thread1->join();
// thread2->join();
// thread3->join();

//     return 0;
// }

// class threadData
// {
//     public:
//     int _number;
//     pthread_t _pid;
//     char _namebuffer[64];
// };
// class threadReturn
// {
//     public:
//     int return_code;
//     int return_num;
// };
// void *start_rontine(void* args)//被多个执行流进入，是可重入函数，处于重入状态
// {
//     threadData*td =static_cast<threadData*> (args);
//     //type2 x=static_cast<type1>(type1 y)将类型为type1的变量y安全转化为类型为type2的变量x，编译器帮忙检查
//     int cnt=10;
//     while(cnt)
//     {
//         cout<<"create success ,newthread name:"<<td->_namebuffer<<"cnt:"<<cnt--<<endl;
//         sleep(1);
//         //exit(0);//exit用来退出进程的，线程退出导致所处的进程退出，全部线程直接退出
//    // pthread_exit(nullptr);//让当前线程退出
//   // return nullptr;//线程返回退出
//     }
// threadReturn* re=new threadReturn();
// re->return_code=8;
// re->return_num=24;
// return (void*)re;
//     //delete td;
//    // return (void*)520;
//   //  return nullptr;
// }

// #define NUM 10
// int main()
// {
// vector<threadData*> threads;
// for(int i=0;i<NUM;i++)//建立10个新线程
// {
//     threadData* td= new threadData();//td指针指向匿名对象
//     td->_number=i+1;//number自增
//     snprintf(td->_namebuffer,sizeof(td->_namebuffer),"%s:%d","thread",i+1);
//     pthread_create(&td->_pid,nullptr,start_rontine,td);
//     threads.push_back(td);
// }

// for(const auto &it:threads)
// {
//     cout<<"create thread: "<<it->_namebuffer<<":"<<it->_pid<<"success"<<endl;
// }

// sleep(5);
// for(int i=0;i<threads.size()/2;i++)
// {
//     pthread_cancel(threads[i]->_pid);//取消线程
//     cout<<"cancel thread: "<<threads[i]->_namebuffer<<"success"<<endl;
// }

// for(const auto &it:threads)
// {
//     void * ret;
//  //  threadReturn* ret=nullptr;

//         int n=pthread_join(it->_pid,(void**)&ret);//将线程的返回值从库中拷贝到ret中
// //    int n=pthread_join(it->_pid,nullptr);//等待回收线程--线程的回收
//     assert(n==0);
//     cout<<"newpthread :"<<it->_namebuffer<<"get success,ret="<<(long long)ret<<endl;
//    // cout<<"newpthread :"<<it->_namebuffer<<"get success,return_code:"<<ret->return_code<<"return_num:"<<ret->return_num<<endl;
//     delete it;//释放线程对应的资源
// }

//     // while(true)
//     // {
//     //     cout<<"old thread create success ,oldthread name: main thread"<<endl;
//     //     sleep(1);
//     // }
// }


// // void *start_rontine(void *args)
// // {
// //     string name=static_cast<const char*> (args);
// //     while(true)
// //     {
// //         cout<<"new thread create success ,newthread name:"<<name<<endl;
// //         sleep(1);
// //     }
// // }

// // int main()
// // {
// //     pthread_t id;
// //     pthread_create(&id,nullptr,start_rontine,(void*)"thread one");
// //         while(true)
// //     {
// //         cout<<"old thread create success ,oldthread name: main thread"<<endl;
// //         sleep(1);
// //     }

// //     return 0;
// // }